#include <cstdlib>
#include <iostream>
#include <cstdio>
#include <cmath>

namespace GEO {
	const double eps = 0.0000001;
#ifndef M_PI
	const double M_PI = 3.14159265358979323846;
#endif
	enum SIDE_STATE {OUT, IN, ON};


	typedef struct TPoint {
		double x, y;
	} TPoint;

	TPoint tPoint(double x, double y) {
		TPoint t;
		t.x = x;
		t.y = y;
		return t;
	}

	typedef struct TShape {
		int num;
		bool isClockwise;
		TPoint* points;
	} TShape;

	TPoint operator + (TPoint a, TPoint b) {
		TPoint res;
		res.x = a.x + b.x;
		res.y = a.y + b.y;
		return res;
	}

	TPoint operator - (TPoint a) {
		TPoint res;
		res.x = -a.x;
		res.y = -a.y;
		return res;
	}
	TPoint operator - (TPoint a, TPoint b) {
		TPoint res;
		res.x = a.x - b.x;
		res.y = a.y - b.y;
		return res;
	}
	TPoint operator * (double s, TPoint x) {
		TPoint res;
		res.x = s*x.x;
		res.y = s*x.y;
		return res;
	}
	TPoint operator / (TPoint x, double y) {
		TPoint res;
		res.x = x.x / y;
		res.y = x.y / y;
		return res;
	}
	bool eq(double x, double y) {return fabs(x-y)<eps;}
	bool operator == (TPoint a, TPoint b) {return eq(a.x, b.x) && eq(a.y, b.y);}

	std::ostream& operator<<(std::ostream& os, const TPoint& a) {
		return os << a.x << " " << a.y;
	}
	std::istream& operator>>(std::istream& is, TPoint& a) {
		return is >> a.x >> a.y;
	}

	double sqr(double x) {return x*x;}

	double norm2(TPoint a) {return sqr(a.x) + sqr(a.y);}

	double norm(TPoint a) {return sqrt(norm2(a));}
	
	TPoint normalizeTo(TPoint x, double len) {return len/norm(x)*x;}

	double cross(TPoint a, TPoint b){return a.x*b.y - b.x*a.y;}

	double dot(TPoint a, TPoint b) {return a.x*b.x + a.y*b.y;}

	double calArea(TShape poly) {
		double area = 0;
		for (int i=0; i<poly.num; ++i)
			area += cross(poly.points[i], poly.points[i+1]);
		return fabs(area/2);
	}

	SIDE_STATE inShape(TPoint a, TShape s) {
		double deg = 0, tot = 0;
		TPoint u, v;
		for (int i=0; i<s.num; ++i) {
			u = s.points[i] - a;
			v = s.points[i+1] - a;
			deg = asin(cross(u, v) / (norm2(u)*norm2(v)));
			if (norm2(s.points[i]-s.points[i+1]) > norm2(u) + norm2(v)) {
				if (deg < eps) deg = -M_PI - deg;
				else if (deg > eps) deg = M_PI - deg;
				else {
					if (s.isClockwise) deg = -M_PI;
					else deg = M_PI;
					return ON;
				}
			}
			tot += deg;
		}
		return (fabs(tot)>1)?IN:OUT;//deg = 0(out) or deg = -2PI(in) or deg = 2PI(in)
	}

	TPoint rotate(TPoint p, double alpha) {
		return tPoint(p.x*cos(alpha)-p.y*sin(alpha), p.x*sin(alpha)+p.y*cos(alpha));
	}

	TPoint getIntersection(TPoint a, TPoint b, TPoint u, TPoint v) {
		TPoint ret;
		double t1, t2;
		t1 = fabs(cross(u-a, v-a));
		t2 = fabs(cross(u-b, v-b));
		if (t1+t2 < eps) {
			t1 = dot(u-a, b-a);
			if (t1 > 0) ret = u;
			else ret = a;
		}
		else {
			ret.x = a.x+ t1/(t2+t1)*(b.x - a.x);
			ret.y = a.y+ t1/(t2+t1)*(b.y - a.y);
		}
		return ret;
	}

	double absoluteAngel(TPoint x) {
		TPoint v = tPoint(100, 0);
		double rad = asin(cross(v, x) / (norm(x)*norm(v)));
		if (dot(v, x) < 0) {
			if (rad < 0)
				rad = -M_PI - rad;
			else
				rad = M_PI - rad;
		}
		return rad;
	}

	double tangentAngel(TPoint p, TPoint center, double r) {
		return 2 * fabs(asin(r/norm(center-p)));
	}

	TPoint tangentPoint(TPoint p, TPoint center, double r, int pOrN) {
		double angel = fabs(asin(r/norm(center-p)));
		return p + rotate(center - p, (pOrN>0)?angel:-angel);
	}

	bool crossEach(TPoint a, TPoint b, TPoint u, TPoint v) {
		double c1 = cross(u-a, v-a);
		double c2 = cross(u-b, v-b);
		if (c1*c2 >= 0) return false;
		c1 = cross(a-u, b-u);
		c2 = cross(a-v, b-v);
		if (c1*c2 >= 0) return false;
		return true;
	}
}

using namespace std;
using namespace GEO;

TPoint point[3];

void solve(TPoint x, TPoint y, TPoint z) {
	if (cross(y-x, z-x)>0) swap(y,z);

// 	cout << x << "  " << y << "  " << z << endl;

	TPoint midxy, midyz;
	midxy = (x+y) / 2;
	midyz = (y+z) / 2;

// 	cout << "midxy: " << midxy << "   midyz: " << midyz << endl;

	TPoint r1, r2;
	r1 = rotate((y-midxy), -M_PI/2);
	r2 = rotate((y-midyz), M_PI/2);

// 	cout << "r1: " << r1 << "  r2: " << r2 << endl;

	TPoint ur1, ur2;
	ur1 = -r1;
	ur2 = -r2;
	while (!crossEach(midxy+ur1, midxy+r1, midyz+ur2, midyz+r2)) {
		r1 = 10*r1;
		r2 = 10*r2;
		ur1 = -r1;
		ur2 = -r2;
	}
	TPoint center = getIntersection(midxy+ur1, midxy+r1, midyz+ur2, midyz+r2);
	double radius = norm(center - x);

	char sign1, sign2;
	sign1 = (center.x<0)?'+':'-';
	sign2 = (center.y<0)?'+':'-';

// 	if (fabs(center.x) < eps)
// 		printf("x^2 + ");
// 	else
		printf("(x %c %.3lf)^2 + ", sign1, fabs(center.x));
// 	if (fabs(center.y) < eps)
// 		printf("y^2 = ");
// 	else
		printf("(y %c %.3lf)^2 = ", sign2, fabs(center.y));
	printf("%.3lf^2\n", radius);

	double lastNum = sqr(center.x) + sqr(center.y) - sqr(radius);
	char sign3;
	sign3 = (lastNum<0)?'-':'+';
	printf("x^2 + y^2 ");
// 	if (fabs(center.x) > eps)
		printf("%c %.3lfx ", sign1, 2*fabs(center.x));
// 	if (fabs(center.y) > eps)
		printf("%c %.3lfy ",sign2, 2*fabs(center.y));
// 	if (fabs(lastNum) > eps)
		printf("%c %.3lf ", sign3, fabs(lastNum));
	printf("= 0\n");
}

int main(void)
{
	while (true) {
		cin >> point[0] >> point[1] >> point[2];
		if (cin.fail()) break;
		solve(point[0], point[1], point[2]);
		cout << endl;
	}
	return 0;
}